export const ObjectData = [
    {
        key: 1,
        name: "assign",
        remark: "两个对象合并",
        use: "_.assign(object, [sources])",
        description: `
分配来源对象的可枚举属性到目标对象上。 来源对象的应用规则是从左到右，随后的下一个对象的属性会覆盖上一个对象的属性。
注意: 这方法会改变 object，参考自Object.assign.
        `,
        argument: `
1.object (Object): 目标对象。
2.[sources] (...Object): 来源对象。
        `,
        return: "(Object): 返回 object.",
        case: `
function Foo() {
  this.a = 1;
}

function Bar() {
  this.c = 3;
}

Foo.prototype.b = 2;
Bar.prototype.d = 4;

_.assign({ 'a': 0 }, new Foo, new Bar);
// => { 'a': 1, 'c': 3 }
        `,
    },
    {
        key: 2,
        name: "assignIn",
        remark: "将来源的对象合并到目标对象",
        use: "_.assignIn(object, [sources])",
        description: `
            这个方法类似_.assign， 除了它会遍历并继承来源对象的属性。
Note: 这方法会改变 object。
        `,
        argument: `
1.object (Object): 目标对象。
2.[sources] (...Object): 来源对象。
        `,
        return: "(Object): 返回 object。",
        case: `
function Foo() {
  this.a = 1;
}

function Bar() {
  this.c = 3;
}

Foo.prototype.b = 2;
Bar.prototype.d = 4;

_.assignIn({ 'a': 0 }, new Foo, new Bar);
// => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
        `,
    },
    {
        key: 3,
        name: "assignInWith",
        remark: "自定义对象属性合并规则",
        use: "_.assignInWith(object, sources, [customizer])",
        description: `
            这个方法类似_.assignIn， 除了它接受一个 customizer ，被调用以产生所分配的值。 如果 customizer 返回 undefined 将会由分配处理方法代替。 customizer 会传入5个参数： (objValue, srcValue, key, object, source)。
Note: 这方法会改变 object。
        `,
        argument: `
1.object (Object): 目标对象。
2.sources (...Object): 来源对象。
3.[customizer] (Function): 这个函数用来自定义分配的值。
        `,
        return: "(Object): 返回 object。",
        case: `
function customizer(objValue, srcValue) {
  return _.isUndefined(objValue) ? srcValue : objValue;
}

var defaults = _.partialRight(_.assignInWith, customizer);

defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
// => { 'a': 1, 'b': 2 }
        `,
    },
    {
        key: 4,
        name: "assignWith",
        remark: "自定义对象属性合并规则",
        use: "_.assignWith(object, sources, [customizer])",
        description: `
            这个方法类似_.assign ， 除了它接受一个 customizer 决定如何分配值。 如果customizer返回 undefined 将会由分配处理方法代替。customizer 会传入5个参数： (objValue, srcValue, key, object, source)。
Note: 这方法会改变 object.
        `,
        argument: `
1.object (Object): 目标对象。
2.sources (...Object): 来源对象。
3.[customizer] (Function): 这个函数用来自定义分配的值。
        `,
        return: "(Object): 返回 object.",
        case: `
function customizer(objValue, srcValue) {
  return _.isUndefined(objValue) ? srcValue : objValue;
}

var defaults = _.partialRight(_.assignWith, customizer);

defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
// => { 'a': 1, 'b': 2 }
        `,
    },
    {
        key: 5,
        name: "at",
        remark: "给定对象中数组中的路径返回对应的值",
        use: "_.at(object, [paths])",
        description: `
            创建一个数组，值来自 object 的paths路径相应的值。
        `,
        argument: `
1.object (Object): 要迭代的对象。
2.[paths] (...(string|string[])): 要获取的对象的元素路径，单独指定或者指定在数组中。
        `,
        return: "(Array): 返回选中值的数组。",
        case: `
var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };

_.at(object, ['a[0].b.c', 'a[1]']);
// => [3, 4]
        `,
    },
    {
        key: 6,
        name: "create",
        remark: "将待分配属性给需要继承的对象【从案例看不理解】",
        use: "_.create(prototype, [properties])",
        description: `
            创建一个继承 prototype 的对象。 如果提供了 prototype，它的可枚举属性会被分配到创建的对象上。
        `,
        argument: `
1.prototype (Object): 要继承的对象。
2.[properties] (Object): 待分配的属性。
        `,
        return: "(Object): 返回新对象。",
        case: `
function Shape() {
  this.x = 0;
  this.y = 0;
}

function Circle() {
  Shape.call(this);
}

Circle.prototype = _.create(Shape.prototype, {
  'constructor': Circle
});

var circle = new Circle;
circle instanceof Circle;
// => true

circle instanceof Shape;
// => true
        `,
    },
    {
        key: 7,
        name: "defaults",
        remark: "合并多个对象，同属性先出现先生效",
        use: "_.defaults(object, [sources])",
        description: `
            分配来源对象的可枚举属性到目标对象所有解析为 undefined 的属性上。 来源对象从左到右应用。 一旦设置了相同属性的值，后续的将被忽略掉。
注意: 这方法会改变 object.
        `,
        argument: `
1.object (Object): 目标对象。
2.[sources] (...Object): 来源对象。
        `,
        return: "(Object): 返回 object。",
        case: `
_.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
// => { 'a': 1, 'b': 2 }
        `,
    },
    {
        key: 8,
        name: "defaultsDeep",
        remark: "合并多个对象，同属性先出现先生效，递归处理多层嵌套对象",
        use: "_.defaultsDeep(object, [sources])",
        description: `
            这个方法类似_.defaults，除了它会递归分配默认属性。注意: 这方法会改变 object.
        `,
        argument: `
1.object (Object): 目标对象。
2.[sources] (...Object): 来源对象。
        `,
        return: "(Object): 返回 object。",
        case: `
_.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
// => { 'a': { 'b': 2, 'c': 3 } }
        `,
    },
    {
        key: 9,
        name: "toPairs -> _.entries",
        remark: "返回对象的可枚举属性键值对数组",
        use: "_.toPairs(object)",
        description: `
            创建一个object对象自身可枚举属性的键值对数组。这个数组可以通过_.fromPairs撤回。如果object 是 map 或 set，返回其条目。
        `,
        argument: `
object (Object): 要检索的对象。
        `,
        return: "(Array): 返回键值对的数组。",
        case: `
function Foo() {
  this.a = 1;
  this.b = 2;
}

Foo.prototype.c = 3;

_.toPairs(new Foo);
// => [['a', 1], ['b', 2]] (iteration order is not guaranteed)
        `,
    },
    {
        key: 10,
        name: "toPairsIn -> _.entriesIn",
        remark: "方法同上，区别是通过object.prototype.key = value方式赋值的属性toPairs不会打印而toPairsIn会",
        use: "_.toPairsIn(object)",
        description: `
            创建一个object对象自身和继承的可枚举属性的键值对数组。这个数组可以通过_.fromPairs撤回。如果object 是 map 或 set，返回其条目。
        `,
        argument: `
object (Object): 要检索的对象。
        `,
        return: "(Array): 返回键值对的数组。",
        case: `
function Foo() {
  this.a = 1;
  this.b = 2;
}

Foo.prototype.c = 3;

_.toPairsIn(new Foo);
// => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)
        `,
    },
    {
        key: 11,
        name: "findKey",
        remark: "按条件返回检索到的key",
        use: "_.findKey(object, [predicate=_.identity])",
        description: `
            这个方法类似_.find 。 除了它返回最先被 predicate 判断为真值的元素 key，而不是元素本身。
        `,
        argument: `
1.object (Object): 需要检索的对象。
2.[predicate=_.identity] (Function): 每次迭代时调用的函数。
        `,
        return: "(*): 返回匹配的 key，否则返回 undefined。",
        case: `
var users = {
  'barney':  { 'age': 36, 'active': true },
  'fred':    { 'age': 40, 'active': false },
  'pebbles': { 'age': 1,  'active': true }
};
 
_.findKey(users, function(o) { return o.age < 40; });
// => 'barney' (iteration order is not guaranteed)
 
// The _.matches iteratee shorthand.
_.findKey(users, { 'age': 1, 'active': true });
// => 'pebbles'
 
// The _.matchesProperty iteratee shorthand.
_.findKey(users, ['active', false]);
// => 'fred'
 
// The _.property iteratee shorthand.
_.findKey(users, 'active');
// => 'barney'
        `,
    },
    {
        key: 12,
        name: "findLastKey",
        remark: "从反方向按条件返回检索到的key",
        use: "_.findLastKey(object, [predicate=_.identity])",
        description: `
            这个方法类似_.findKey。 不过它是反方向开始遍历的。
        `,
        argument: `
1.object (Object): 需要检索的对象。
2.[predicate=_.identity] (Function): 每次迭代时调用的函数。
        `,
        return: "(*): 返回匹配的 key，否则返回 undefined.",
        case: `
var users = {
  'barney':  { 'age': 36, 'active': true },
  'fred':    { 'age': 40, 'active': false },
  'pebbles': { 'age': 1,  'active': true }
};
 
_.findLastKey(users, function(o) { return o.age < 40; });
// => returns 'pebbles' assuming _.findKey returns 'barney'
 
// The _.matches iteratee shorthand.
_.findLastKey(users, { 'age': 36, 'active': true });
// => 'barney'
 
// The _.matchesProperty iteratee shorthand.
_.findLastKey(users, ['active', false]);
// => 'fred'
 
// The _.property iteratee shorthand.
_.findLastKey(users, 'active');
// => 'pebbles'
        `,
    },
    {
        key: 13,
        name: "forIn",
        remark: "遍历对象执行处理",
        use: "_.forIn(object, [iteratee=_.identity])",
        description: `
            使用 iteratee 遍历对象的自身和继承的可枚举属性。 iteratee 会传入3个参数：(value, key, object)。 如果返回 false，iteratee 会提前退出遍历。
        `,
        argument: `
1.object (Object): 要遍历的对象。
2.[iteratee=_.identity] (Function): 每次迭代时调用的函数。
        `,
        return: "(Object): 返回 object。",
        case: `
function Foo() {
  this.a = 1;
  this.b = 2;
}

Foo.prototype.c = 3;

_.forIn(new Foo, function(value, key) {
  console.log(key);
});
// => Logs 'a', 'b', then 'c' (无法保证遍历的顺序)。
        `,
    },
    {
        key: 14,
        name: "forInRight",
        remark: "从反方向遍历对象执行处理",
        use: "_.forInRight(object, [iteratee=_.identity])",
        description: `
            这个方法类似_.forIn。 除了它是反方向开始遍历object的。
        `,
        argument: `
1.object (Object): 要遍历的对象。
2.[iteratee=_.identity] (Function): 每次迭代时调用的函数。
        `,
        return: "(Object): 返回 object。",
        case: `
function Foo() {
  this.a = 1;
  this.b = 2;
}
 
Foo.prototype.c = 3;
 
_.forInRight(new Foo, function(value, key) {
  console.log(key);
});
// => 输出 'c', 'b', 然后 'a'， _.forIn 会输出 'a', 'b', 然后 'c'。
        `,
    },
    {
        key: 15,
        name: "forOwn",
        remark: "遍历对象执行处理，object.prototype.key = value方式赋值的属性不进行遍处理",
        use: "_.forOwn(object, [iteratee=_.identity])",
        description: `
            使用 iteratee 遍历自身的可枚举属性。 iteratee 会传入3个参数：(value, key, object)。 如果返回 false，iteratee 会提前退出遍历。
        `,
        argument: `
(Object): 返回 object。
        `,
        return: "(Object): 返回 object。",
        case: `
function Foo() {
  this.a = 1;
  this.b = 2;
}

Foo.prototype.c = 3;

_.forOwn(new Foo, function(value, key) {
  console.log(key);
});
// => 输出 'a' 然后 'b' (无法保证遍历的顺序)。
        `,
    },
    {
        key: 16,
        name: "forOwnRight",
        remark: "反方向开始遍历对象执行处理，object.prototype.key = value方式赋值的属性不进行处理",
        use: "_.forOwnRight(object, [iteratee=_.identity])",
        description: `
            这个方法类似_.forOwn。 除了它是反方向开始遍历object的。
        `,
        argument: `
1.object (Object): 要遍历的对象。
2.[iteratee=_.identity] (Function): 每次迭代时调用的函数。
        `,
        return: "(Object): 返回 object。",
        case: `
function Foo() {
  this.a = 1;
  this.b = 2;
}
 
Foo.prototype.c = 3;
 
_.forOwnRight(new Foo, function(value, key) {
  console.log(key);
});
// =>  输出 'b' 然后 'a'， _.forOwn 会输出 'a' 然后 'b'
        `,
    },
    {
        key: 17,
        name: "functions",
        remark: "将对象的属性遍历放入数组，不包含object.prototype.key = value",
        use: "_.functions(object)",
        description: `
            创建一个函数属性名称的数组，函数属性名称来自object对象自身可枚举属性。
        `,
        argument: `
object (Object): 要检查的对象。
        `,
        return: "(Array): 返回函数名。",
        case: `
function Foo() {
  this.a = _.constant('a');
  this.b = _.constant('b');
}

Foo.prototype.c = _.constant('c');

_.functions(new Foo);
// => ['a', 'b']
        `,
    },
    {
        key: 18,
        name: "functionsIn",
        remark: "将对象的属性遍历放入数组，包含object.prototype.key = value",
        use: "_.functionsIn(object)",
        description: `
            创建一个函数属性名称的数组，函数属性名称来自object对象自身和继承的可枚举属性。
        `,
        argument: `
object (Object): 要检查的对象。
        `,
        return: "(Array): 返回函数名。",
        case: `
function Foo() {
  this.a = _.constant('a');
  this.b = _.constant('b');
}

Foo.prototype.c = _.constant('c');

_.functionsIn(new Foo);
// => ['a', 'b', 'c']
        `,
    },
    {
        key: 19,
        name: "get",
        remark: "给定对象的属性路径返回其value",
        use: "_.get(object, path, [defaultValue])",
        description: `
            根据 object对象的path路径获取值。 如果解析 value 是 undefined 会以 defaultValue 取代。
        `,
        argument: `
1.object (Object): 要检索的对象。
2.path (Array|string): 要获取属性的路径。
3.[defaultValue] (*): 如果解析值是 undefined ，这值会被返回。
        `,
        return: "(*): 返回解析的值。",
        case: `
var object = { 'a': [{ 'b': { 'c': 3 } }] };

_.get(object, 'a[0].b.c');
// => 3

_.get(object, ['a', '0', 'b', 'c']);
// => 3

_.get(object, 'a.b.c', 'default');
// => 'default'
        `,
    },
    {
        key: 20,
        name: "has",
        remark: "检查 path 是否是object对象的直接属性",
        use: "_.has(object, path)",
        description: `
            检查 path 是否是object对象的直接属性。
        `,
        argument: `
1.object (Object): 要检索的对象。
2.path (Array|string): 要检查的路径path。
        `,
        return: "(boolean): 如果path存在，那么返回 true ，否则返回 false。",
        case: `
var object = { 'a': { 'b': 2 } };
var other = _.create({ 'a': _.create({ 'b': 2 }) });

_.has(object, 'a');
// => true

_.has(object, 'a.b');
// => true

_.has(object, ['a', 'b']);
// => true

_.has(other, 'a');
// => false
        `,
    },
    {
        key: 21,
        name: "hasIn",
        remark: "检查路径判断是否是object的属性，返回Boolean值",
        use: "_.hasIn(object, path)",
        description: `
            检查 path 是否是object对象的直接或继承属性。
        `,
        argument: `
1.object (Object): 要检索的对象。
2.path (Array|string): 要检查的路径path。
        `,
        return: "(boolean): 如果path存在，那么返回 true ，否则返回 false。",
        case: `
var object = _.create({ 'a': _.create({ 'b': 2 }) });

_.hasIn(object, 'a');
// => true

_.hasIn(object, 'a.b');
// => true

_.hasIn(object, ['a', 'b']);
// => true

_.hasIn(object, 'b');
// => false
        `,
    },
    {
        key: 22,
        name: "invert",
        remark: "对象键值对倒置，重复值会取后出现的",
        use: "_.invert(object)",
        description: `
            创建一个object键值倒置后的对象。 如果 object 有重复的值，后面的值会覆盖前面的值。
        `,
        argument: `
object (Object): 要键值倒置对象。
        `,
        return: "(Object): 返回新的键值倒置后的对象。",
        case: `
var object = { 'a': 1, 'b': 2, 'c': 1 };

_.invert(object);
// => { '1': 'c', '2': 'b' }
        `,
    },
    {
        key: 23,
        name: "invertBy",
        remark: "倒置对象键值对，重复值设置为数组并可以处理原对象values",
        use: "_.invertBy(object, [iteratee=_.identity])",
        description: `
            这个方法类似_.invert，除了倒置对象 是 collection（集合）中的每个元素经过 iteratee（迭代函数） 处理后返回的结果。每个反转键相应反转的值是一个负责生成反转值key的数组。iteratee 会传入3个参数：(value) 。
        `,
        argument: `
1.object (Object): 要键值倒置对象。
2.[iteratee=_.identity] (Function): 每次迭代时调用的函数。
        `,
        return: "(Object): 返回新的键值倒置后的对象。",
        case: `
var object = { 'a': 1, 'b': 2, 'c': 1 };

_.invertBy(object);
// => { '1': ['a', 'c'], '2': ['b'] }

_.invertBy(object, function(value) {
  return 'group' + value;
});
// => { 'group1': ['a', 'c'], 'group2': ['b'] }
        `,
    },
    {
        key: 24,
        name: "invoke",
        remark: "对对象指定路径属性进行处理，返回结果",
        use: "_.invoke(object, path, [args])",
        description: `
            调用object对象path上的方法。
        `,
        argument: `
1.object (Object): 要检索的对象。
2.path (Array|string): 用来调用的方法路径。
3.[args] (...*): 调用的方法的参数。
        `,
        return: "(*): 返回调用方法的结果。",
        case: `
var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };

_.invoke(object, 'a[0].b.c.slice', 1, 3);
// => [2, 3]
        `,
    },
    {
        key: 25,
        name: "keys",
        remark: "返回对象的属性数组（不包含prototype）",
        use: "_.keys(object)",
        description: `
            创建一个 object 的自身可枚举属性名为数组。
Note: 非对象的值会被强制转换为对象，查看ES spec 了解详情。
        `,
        argument: `
object (Object): 要检索的对象。
        `,
        return: "(Array): 返回包含属性名的数组。",
        case: `
function Foo() {
  this.a = 1;
  this.b = 2;
}

Foo.prototype.c = 3;

_.keys(new Foo);
// => ['a', 'b'] (iteration order is not guaranteed)

_.keys('hi');
// => ['0', '1']
        `,
    },
    {
        key: 26,
        name: "keysIn",
        remark: "返回对象的属性数组（包含prototype）",
        use: "_.keysIn(object)",
        description: `
            创建一个 object 自身 和 继承的可枚举属性名为数组。注意: 非对象的值会被强制转换为对象。
        `,
        argument: `
object (Object): 要检索的对象。
        `,
        return: "(Array): 返回包含属性名的数组。",
        case: `
function Foo() {
  this.a = 1;
  this.b = 2;
}

Foo.prototype.c = 3;

_.keysIn(new Foo);
// => ['a', 'b', 'c'] (iteration order is not guaranteed)
        `,
    },
    {
        key: 27,
        name: "mapKeys",
        remark: "对对象进行遍历，按照函数处理修改属性名，值保持不变，返回对象",
        use: ".mapKeys(object, [iteratee=_.identity])",
        description: `
            反向版_.mapValues。 这个方法创建一个对象，对象的值与object相同，并且 key 是通过 iteratee 运行 object 中每个自身可枚举属性名字符串 产生的。iteratee调用三个参数： (value, key, object)。
        `,
        argument: `
1.object (Object): 要遍历的对象。
2.[iteratee=_.identity] (Function): 每次迭代时调用的函数。
        `,
        return: "(Object): 返回映射后的新对象。",
        case: `
_.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
  return key + value;
});
// => { 'a1': 1, 'b2': 2 }
        `,
    },
    {
        key: 28,
        name: "mapValues",
        remark: "遍历对象，key保留对value进行处理",
        use: "_.mapValues(object, [iteratee=_.identity])",
        description: `
            创建一个对象，这个对象的key与object对象相同，值是通过 iteratee 运行 object 中每个自身可枚举属性名字符串产生的。 iteratee调用三个参数： (value, key, object)。
        `,
        argument: `
1.object (Object): 要遍历的对象。
2.[iteratee=_.identity] (Function): 每次迭代时调用的函数。
        `,
        return: "(Object): 返回映射后的新对象。",
        case: `
var users = {
  'fred':    { 'user': 'fred',    'age': 40 },
  'pebbles': { 'user': 'pebbles', 'age': 1 }
};
 
_.mapValues(users, function(o) { return o.age; });
// => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
 
// The _.property iteratee shorthand.
_.mapValues(users, 'age');
// => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
        `,
    },
    {
        key: 29,
        name: "merge",
        remark: "合并对象，数组同下标进行合并",
        use: "_.merge(object, [sources])",
        description: `
            该方法类似_.assign， 除了它递归合并 sources 来源对象自身和继承的可枚举属性到 object 目标对象。如果目标值存在，被解析为undefined的sources 来源对象属性将被跳过。数组和普通对象会递归合并，其他对象和值会被直接分配覆盖。源对象从从左到右分配。后续的来源对象属性会覆盖之前分配的属性。Note: 这方法会改变对象 object.
        `,
        argument: `
1.object (Object): 目标对象。
2.[sources] (...Object): 来源对象。
        `,
        return: "(Object): 返回 object.",
        case: `
var object = {
  'a': [{ 'b': 2 }, { 'd': 4 }]
};

var other = {
  'a': [{ 'c': 3 }, { 'e': 5 }]
};

_.merge(object, other);
// => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
        `,
    },
    {
        key: 30,
        name: "mergeWith",
        remark: "类似merge，不同之处是相同key下的数组都会合并",
        use: "_.mergeWith(object, sources, customizer)",
        description: `
            该方法类似_.merge，除了它接受一个 customizer，调用以产生目标对象和来源对象属性的合并值。如果customizer 返回 undefined，将会由合并处理方法代替。customizer调用与7个参数：(objValue, srcValue, key, object, source, stack)。Note: 这方法会改变对象 object.
        `,
        argument: `
1.object (Object): 目标对象。
2.[sources] (...Object): 来源对象。
3.customizer (Function): 这个函数定制合并值。
        `,
        return: "(Object): 返回 object。",
        case: `
function customizer(objValue, srcValue) {
  if (_.isArray(objValue)) {
    return objValue.concat(srcValue);
  }
}

var object = { 'a': [1], 'b': [2] };
var other = { 'a': [3], 'b': [4] };

_.mergeWith(object, other, customizer);
// => { 'a': [1, 3], 'b': [2, 4] }
        `,
    },
    {
        key: 31,
        name: "omit",
        remark: "删除对象指定属性返回新对象",
        use: "_.omit(object, [props])",
        description: `
            反向版_.pick; 这个方法一个对象，这个对象由忽略属性之外的object自身和继承的可枚举属性组成。（注：可以理解为删除object对象的属性）。
        `,
        argument: `
1.object (Object): 来源对象。
2.[props] (...(string|string[])): 要被忽略的属性。（注：单独指定或指定在数组中。）
        `,
        return: "(Object): 返回新对象。",
        case: `
var object = { 'a': 1, 'b': '2', 'c': 3 };

_.omit(object, ['a', 'c']);
// => { 'b': '2' }
        `,
    },
    {
        key: 32,
        name: "omitBy",
        remark: "对对象value进行处理，返回为true的删除",
        use: "_.omitBy(object, [predicate=_.identity])",
        description: `
            反向版_.pickBy；这个方法一个对象，这个对象忽略 predicate（断言函数）判断不是真值的属性后，object自身和继承的可枚举属性组成。predicate调用与2个参数：(value, key)。
        `,
        argument: `
1.object (Object): 来源对象。
2.[predicate=_.identity] (Function): 调用每一个属性的函数。
        `,
        return: "(Object): 返回新对象。",
        case: `
var object = { 'a': 1, 'b': '2', 'c': 3 };

_.omitBy(object, _.isNumber);
// => { 'b': '2' }
        `,
    },
    {
        key: 33,
        name: "pick",
        remark: "返回指定key的新对象",
        use: "_.pick(object, [props])",
        description: `
            创建一个从 object 中选中的属性的对象。
        `,
        argument: `
1.object (Object): 来源对象。
2.[props] (...(string|string[])): 要被忽略的属性。（注：单独指定或指定在数组中。）
        `,
        return: "(Object): 返回新对象。",
        case: `
var object = { 'a': 1, 'b': '2', 'c': 3 };

_.pick(object, ['a', 'c']);
// => { 'a': 1, 'c': 3 }
        `,
    },
    {
        key: 34,
        name: "pickBy",
        remark: "对对象每个属性进行处理，符合条件的保留返回新的对象",
        use: "_.pickBy(object, [predicate=_.identity])",
        description: `
            创建一个对象，这个对象组成为从 object 中经 predicate 判断为真值的属性。 predicate调用2个参数：(value, key)。
        `,
        argument: `
1.object (Object): 来源对象。
2.[predicate=_.identity] (Function): 调用每一个属性的函数。
        `,
        return: "(Object): 返回新对象。",
        case: `
var object = { 'a': 1, 'b': '2', 'c': 3 };

_.pickBy(object, _.isNumber);
// => { 'a': 1, 'c': 3 }
        `,
    },
    {
        key: 35,
        name: "result",
        remark: "【没理解】",
        use: "_.result(object, path, [defaultValue])",
        description: `
            这个方法类似_.get， 除了如果解析到的值是一个函数的话，就绑定 this 到这个函数并返回执行后的结果。
        `,
        argument: `
1.object (Object): 要检索的对象。
2.path (Array|string): 要解析的属性路径。
3.[defaultValue] (*): 如果值解析为 undefined，返回这个值。
        `,
        return: "(*): 返回解析后的值。",
        case: `
var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };

_.result(object, 'a[0].b.c1');
// => 3

_.result(object, 'a[0].b.c2');
// => 4

_.result(object, 'a[0].b.c3', 'default');
// => 'default'

_.result(object, 'a[0].b.c3', _.constant('default'));
// => 'default'
        `,
    },
    {
        key: 36,
        name: "set",
        remark: "设置对象属性路径上值，不存在则创建",
        use: "_.set(object, path, value)",
        description: `
            设置 object对象中对应 path 属性路径上的值，如果path不存在，则创建。 缺少的索引属性会创建为数组，而缺少的属性会创建为对象。 使用_.setWith 定制path创建。Note: 这个方法会改变 object。
        `,
        argument: `
1.object (Object): 要修改的对象。
2.path (Array|string): 要设置的对象路径。
3.value (*): 要设置的值。
        `,
        return: "(Object): 返回 object。",
        case: `
var object = { 'a': [{ 'b': { 'c': 3 } }] };

_.set(object, 'a[0].b.c', 4);
console.log(object.a[0].b.c);
// => 4

_.set(object, ['x', '0', 'y', 'z'], 5);
console.log(object.x[0].y.z);
// => 5
        `,
    },
    {
        key: 37,
        name: "setWith",
        remark: "对对象路径修改值【参数4未理解】",
        use: "_.setWith(object, path, value, [customizer])",
        description: `
            这个方法类似_.set，除了它接受一个 customizer，调用生成对象的 path。 如果 customizer 返回 undefined 将会有它的处理方法代替。 customizer 调用3个参数： (nsValue, key, nsObject)。注意: 这个方法会改变 object.
        `,
        argument: `
1.object (Object): 要修改的对象。
2.path (Array|string): 要设置的对象路径。
3.value (*): 要设置的值。
4.[customizer] (Function): 这个函数用来定制分配的值。
        `,
        return: "(Object): 返回 object。",
        case: `
var object = {};

_.setWith(object, '[0][1]', 'a', Object);
// => { '0': { '1': 'a' } }
        `,
    },
    {
        key: 38,
        name: "transform",
        remark: "处理自身可枚举属性【不理解】",
        use: "_.transform(object, [iteratee=_.identity], [accumulator])",
        description: `
_.reduce的替代方法;此方法将转换object对象为一个新的accumulator对象，结果来自iteratee处理自身可枚举的属性。 每次调用可能会改变 accumulator 对象。如果不提供accumulator，将使用与[[Prototype]]相同的新对象。iteratee调用4个参数：(accumulator, value, key, object)。如果返回 false，iteratee 会提前退出。
        `,
        argument: `
1.object (Object): 要遍历的对象
2.[iteratee=_.identity] (Function): 每次迭代时调用的函数。
3.[accumulator] (*): 定制叠加的值。
        `,
        return: "(*): 返回叠加后的值。",
        case: `
_.transform([2, 3, 4], function(result, n) {
  result.push(n *= n);
  return n % 2 == 0;
}, []);
// => [4, 9]

_.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
  (result[value] || (result[value] = [])).push(key);
}, {});
// => { '1': ['a', 'c'], '2': ['b'] }
        `,
    },
    {
        key: 39,
        name: "unset",
        remark: "删除对象指定路径属性",
        use: "_.unset(object, path)",
        description: `
移除object对象 path 路径上的属性。注意: 这个方法会改变源对象 object。
        `,
        argument: `
1.object (Object): 要修改的对象。
2.path (Array|string): 要移除的对象路径。
        `,
        return: "(boolean): 如果移除成功，那么返回 true ，否则返回 false。",
        case: `
var object = { 'a': [{ 'b': { 'c': 7 } }] };
_.unset(object, 'a[0].b.c');
// => true

console.log(object);
// => { 'a': [{ 'b': {} }] };

_.unset(object, ['a', '0', 'b', 'c']);
// => true

console.log(object);
// => { 'a': [{ 'b': {} }] };
        `,
    },
    {
        key: 40,
        name: "update",
        remark: "对对象指定路径属性进行参数处理返回对象",
        use: "_.update(object, path, updater)",
        description: `
该方法类似_.set，除了接受updater以生成要设置的值。使用_.updateWith来自定义生成的新path。updater调用1个参数：(value)。Note: 这个方法会改变 object。
        `,
        argument: `
1.object (Object): 要修改的对象。
2.path (Array|string): 要设置属性的路径。
3.updater (Function): 用来生成设置值的函数。
        `,
        return: "(Object): 返回 object 。",
        case: `
var object = { 'a': [{ 'b': { 'c': 3 } }] };

_.update(object, 'a[0].b.c', function(n) { return n * n; });
console.log(object.a[0].b.c);
// => 9

_.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
console.log(object.x[0].y.z);
// => 0
        `,
    },
    {
        key: 41,
        name: "updateWith",
        remark: "类似update【没理解】",
        use: "_.updateWith(object, path, updater, [customizer])",
        description: `
该方法类似_.update，不同之处在于它接受customizer，调用来生成新的对象的path。如果customizer返回undefined，路径创建由该方法代替。customizer调用有三个参数：(nsValue, key, nsObject) 。Note: 这个方法会改变 object.
        `,
        argument: `
1.object (Object): 要修改的对象。
2.path (Array|string): 要设置属性的路径。
3.updater (Function): 用来生成设置值的函数。
4.[customizer] (Function): 用来自定义分配值的函数。
        `,
        return: "(Object): 返回 object.",
        case: `
var object = {};

_.updateWith(object, '[0][1]', _.constant('a'), Object);
// => { '0': { '1': 'a' } }
        `,
    },
    {
        key: 42,
        name: "values",
        remark: "将值放入数组，不包含object.prototype.key",
        use: "_.values(object)",
        description: `
            创建 object 自身可枚举属性的值为数组。注意: 注意: 非对象的值会强制转换为对象。
        `,
        argument: `
object (Object): 要检索的对象。
        `,
        return: "(Array): 返回对象属性的值的数组",
        case: `
function Foo() {
  this.a = 1;
  this.b = 2;
}

Foo.prototype.c = 3;

_.values(new Foo);
// => [1, 2] (无法保证遍历的顺序)

_.values('hi');
// => ['h', 'i']
        `,
    },
    {
        key: 43,
        name: "valuesIn",
        remark: "将值放入数组，包含object.prototype.key",
        use: "_.valuesIn(object)",
        description: `
            创建 object 自身和继承的可枚举属性的值为数组。注意: 注意: 非对象的值会强制转换为对象。
        `,
        argument: `
object (Object): 要检索的对象。
        `,
        return: "(Array): 返回对象属性的值的数组。",
        case: `
function Foo() {
  this.a = 1;
  this.b = 2;
}

Foo.prototype.c = 3;

_.valuesIn(new Foo);
// => [1, 2, 3] (无法保证遍历的顺序)
        `,
    },
];
